CShap和C++ Socket通信

2018-05-21

通信传输数据类型

C++:char*

C#:byte[]

java:byte[]

在C++中：
在C++中，char是基础数据类型，8位，1个字节。byte不是基础数据类型，一般是typedef unsigned char byte;这样子的，也就是说，byte其实是unsigned char类型，那么也是8位，1个字节。不同的是，char可以表示的范围是-128-127，而byte可以表示的范围是0-255。

在Java中：
在java中，char和byte都是基础数据类型，其中的byte和C++中的char类型是一样的，8位，1个字节，-128-127。但是，char类型，是16位，2个字节，’\u0000’-‘\uFFFF’。

为什么java里的char是2个字节？

因为java内部都是用unicode的，所以java其实是支持中文变量名的，比如string 世界 = “我的世界”;这样的语句是可以通过的。

传输不定长度的数据

1 以结束符标记
2 长度 + 数据

#pragma pack(push, 1)
//协议头
struct msg
{
    char     compressflag;     //压缩标志，如果为1，则启用压缩，反之不启用压缩
    int32_t  originsize;       //包体压缩前大小
    int32_t  compresssize;     //包体压缩后大小
    char     reserved[16];
};

#pragma pack(pop)

int32_t可换成msg

发送：

std::string strBuffer,m_strSendBuf；

int32_t length = (int32_t)strBuffer.length();
 m_strSendBuf.append((const char*)&length, sizeof(length));
m_strSendBuf.append(strDestBuf);
nRet = ::send(m_hSocket, m_strSendBuf.c_str(), m_strSendBuf.length(), 0);

接收：

nRet = ::recv(m_hSocket, buff, 10 * 1024, 0);
m_strRecvBuf.append(buff, nRet);
int32_t length;
memcpy_s(&length, sizeof(int32_t), m_strRecvBuf.data(), sizeof(int32_t));
m_strRecvBuf.erase(0, sizeof(int32_t));
std::string strTempMsg = m_strRecvBuf.substr(0, length);

C# 和 C++ 结构体Socket通信

仿照C++结构体写出C#的结构来

using System.Runtime.InteropServices;

[Serializable] // 指示可序列化
[StructLayout(LayoutKind.Sequential, Pack = 1)] // 按1字节对齐
public struct Operator

{
    public ushort id;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 11)] // 声明一个字符数组，大小为11
    public char[] name;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 9)]
    public char[] pass;

    public Operator(string user, string pass) // 初始化
    {
        this.id = 10000;
        this.name = user.PadRight(11, '\0').ToCharArray();
        this.pass = pass.PadRight(9, '\0').ToCharArray();
    }
}

整个结构的字节数是22bytes。

对应的C++结构体是：

typedef struct
{
    WORD id;
    CHAR name[11];
    CHAR password[9];
} Operator;

发送的时候先要把结构转换成字节数组

using System.Runtime.InteropServices;

/// <summary>
/// 将结构转换为字节数组
/// </summary>
/// <param name="obj">结构对象</param>
/// <returns>字节数组</returns>
public byte[] StructToBytes(object obj)
{
    //得到结构体的大小
    int size = Marshal.SizeOf(obj);
    //创建byte数组
    byte[] bytes = new byte[size];
    //分配结构体大小的内存空间
    IntPtr structPtr = Marshal.AllocHGlobal(size);
    //将结构体拷到分配好的内存空间
    Marshal.StructureToPtr(obj, structPtr, false);
    //从内存空间拷到byte数组
    Marshal.Copy(structPtr, bytes, 0, size);
    //释放内存空间
    Marshal.FreeHGlobal(structPtr);
    //返回byte数组
    return bytes;

}

接收的时候需要把字节数组转换成结构

/// <summary>
/// byte数组转结构
/// </summary>
/// <param name="bytes">byte数组</param>
/// <param name="type">结构类型</param>
/// <returns>转换后的结构</returns>
public object BytesToStruct(byte[] bytes, Type type)
{
    //得到结构的大小
    int size = Marshal.SizeOf(type);
    Log(size.ToString(), 1);
    //byte数组长度小于结构的大小
    if (size > bytes.Length)
    {
        //返回空
        return null;
    }
    //分配结构大小的内存空间
    IntPtr structPtr = Marshal.AllocHGlobal(size);
    //将byte数组拷到分配好的内存空间
    Marshal.Copy(bytes, 0, structPtr, size);
    //将内存空间转换为目标结构
    object obj = Marshal.PtrToStructure(structPtr, type);
    //释放内存空间
    Marshal.FreeHGlobal(structPtr);
    //返回结构
    return obj;
}


实际操作：

using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;

byte[] Message = StructToBytes(new Operator("user", "pass")); // 将结构转换成字节数组

TcpClient socket = new TcpClient();

socket.Connect(ip, port);

NetworkStream ns = Socket.GetStream();

ns.Write(Message, 0, Message.Length); // 发送

byte[] Recv = new byte[1024]; // 缓冲

int NumberOfRecv = 0;

IList<byte> newRecv = new List<byte>();
ns.ReadTimeout = 3000;
try
{
    do
    {
        // 接收响应
        NumberOfRecv = ns.Read(Recv, 0, Recv.Length);
        for (int i = 0; i < NumberOfRecv; i++)
            newRecv.Add(Recv[i]);
    }
    while (ns.DataAvailable);
    byte[] resultRecv = new byte[newRecv.Count];
    newRecv.CopyTo(resultRecv, 0);

    Operator MyOper = new Operator();

    MyOper = (Operator)BytesToStruct(resultRecv, MyOper.GetType()); // 将字节数组转换成结构

    在这里取值的时候可能会出现只能取到一个字段，剩余的取不到的问题，怎么回事我也搞不懂，反正我的解决办法就是按照字节的顺序从resultRecv里分别取出对应的字段的字节数组，然后解码，例如：

    Operator.name是11个字节，最后一位是0，Operator.id是2个字节，那么从第3位到第12位的字节就是Operator.name的内容，取出另存为一个数组MyOperName，Encoding.Default.GetString(MyOperName)就是MyOper.name的内容。

    socket.Close();

    ns.Close();

    可以看到，该仁兄在接收解析的时候，还是被C#的默认排序给黑到了，这里还是建议暂时用比较笨的方法，等待大牛出来好方法：
  所以比较笨的解决办法是，把所有定义好的数据结构先手动进行按名字排序！~~

自己对数据结构中的类型名称进行按名字排序